// IR Building Notes

// -----------------

//

// 1. More copy instructions added than necessary

// ----------------------------------------------

// Note that in general, there will be lots of a = b kind of copies

// introduced in the IR because the translation is entirely single-node focused.

// An example will make this clear

//

// RUBY:

//     v = @f

// will translate to

//

// AST:

//     LocalAsgnNode v

//       InstrVarNode f

// will translate to

//

// IR:

//     tmp = self.f [ GET_FIELD(tmp,self,f) ]

//     v = tmp      [ COPY(v, tmp) ]

//

// instead of

//     v = self.f   [ GET_FIELD(v, self, f) ]

//

// We could get smarter and pass in the variable into which this expression is going to get evaluated

// and use that to store the value of the expression (or not build the expression if the variable is null).

//

// But, that makes the code more complicated, and in any case, all this will get fixed in a single pass of

// copy propagation and dead-code elimination.

//

// Something to pay attention to and if this extra pass becomes a concern (not convinced that it is yet),

// this smart can be built in here.  Right now, the goal is to do something simple and straightforward that is going to be correct.

//

// 2. Returning null vs Nil.NIL

// ----------------------------

// - We should be returning null from the build methods where it is a normal "error" condition

// - We should be returning Nil.NIL where the actual return value of a build is the ruby nil operand

//   Look in buildIf for an example of this

    private static final UnexecutableNil U_NIL = UnexecutableNil.U_NIL;

   private static final Operand[] NO_ARGS = new Operand[]{};

    public static void main(String[] args) {

        boolean isDebug = args.length > 0 && args[0].equals("-debug");

        int     i = isDebug ? 1 : 0;

        String methName = null;

        if (args.length > i && args[i].equals("-inline")) {

           methName = args[i+1];

           i += 2;

        }

        boolean isCommandLineScript = args.length > i && args[i].equals("-e");

        i += (isCommandLineScript ? 1 : 0);

        while (i < args.length) {

           long t1 = new Date().getTime();

           Node ast = buildAST(isCommandLineScript, args[i]);

           long t2 = new Date().getTime();

           IRScope scope = new IRBuilder().buildRoot((RootNode) ast);

           long t3 = new Date().getTime();

           if (isDebug) {

               System.out.println("################## Before local optimization pass ##################");

               scope.runCompilerPass(new org.jruby.compiler.ir.compiler_pass.IR_Printer());

           }

           scope.runCompilerPass(new org.jruby.compiler.ir.compiler_pass.opts.LocalOptimizationPass());

           long t4 = new Date().getTime();

           if (isDebug) {

               System.out.println("################## After local optimization pass ##################");

               scope.runCompilerPass(new org.jruby.compiler.ir.compiler_pass.IR_Printer());

           }

           scope.runCompilerPass(new org.jruby.compiler.ir.compiler_pass.CFG_Builder());

           long t5 = new Date().getTime();

           long t6 = new Date().getTime();

           if (methName != null) {

              System.out.println("################## After inline pass ##################");

              System.out.println("Asked to inline " + methName);

              scope.runCompilerPass(new org.jruby.compiler.ir.compiler_pass.InlineTest(methName));

              scope.runCompilerPass(new org.jruby.compiler.ir.compiler_pass.opts.LocalOptimizationPass());

              scope.runCompilerPass(new org.jruby.compiler.ir.compiler_pass.IR_Printer());

           }

           if (isDebug) {

               System.out.println("################## After dead code elimination pass ##################");

           }

           scope.runCompilerPass(new org.jruby.compiler.ir.compiler_pass.LiveVariableAnalysis());

           long t7 = new Date().getTime();

           scope.runCompilerPass(new org.jruby.compiler.ir.compiler_pass.opts.DeadCodeElimination());

           long t8 = new Date().getTime();

           scope.runCompilerPass(new org.jruby.compiler.ir.compiler_pass.AddBindingInstructions());

           long t9 = new Date().getTime();

           if (isDebug) {

               scope.runCompilerPass(new org.jruby.compiler.ir.compiler_pass.IR_Printer());

           }

           scope.runCompilerPass(new org.jruby.compiler.ir.compiler_pass.LinearizeCFG());

           if (isDebug) {

               System.out.println("################## After cfg linearization pass ##################");

               scope.runCompilerPass(new org.jruby.compiler.ir.compiler_pass.IR_Printer());

           }

           System.out.println("Time to build AST         : " + (t2 - t1));

           System.out.println("Time to build IR          : " + (t3 - t2));

           System.out.println("Time to run local opts    : " + (t4 - t3));

           System.out.println("Time to run build cfg     : " + (t5 - t4));

           System.out.println("Time to run build domtree : " + (t6 - t5));

           System.out.println("Time to run lva           : " + (t7 - t6));

           System.out.println("Time to run dead code elim: " + (t8 - t7));

           System.out.println("Time to add frame instrs  : " + (t9 - t8));

           i++;

        }

    }

    /* -----------------------------------------------------------------------------------

     * Every ensure block has a start label and end label, and at the end, it will jump

     * to an address stored in a return address variable.

     *

     * This ruby code will translate to the IR shown below

     * -----------------

     *   begin

     *       ... protected body ...

     *   ensure

     *       ... ensure block to run

     *   end

     * -----------------

     *  IR instructions for the protected body

     *  L_start:

     *     .. ensure block IR ...

     *     jump %ret_addr

     *  L_end:

     * -----------------

     *

     * If N is a node in the protected body that might exit this scope (exception rethrows

     * and returns), N has to first jump to the ensure block and let the ensure block run.

     * In addition, N has to set up a return address label in the return address var of

     * this ensure block so that the ensure block can transfer control block to N.

     *

     * Since we can have a nesting of ensure blocks, we are maintaining a stack of these

     * well-nested ensure blocks.  Every node N that will exit this scope will have to

     * co-ordinate the jumps in-and-out of the ensure blocks in the top-to-bottom stacked

     * order.

     * ----------------------------------------------------------------------------------- */

    private static class EnsureBlockInfo

    {

        Label    start;

        Label    end;

        Variable returnAddr;

        public EnsureBlockInfo(IRScope m)

        {

            returnAddr = m.getNewTemporaryVariable();

            start      = m.getNewLabel();

            end        = m.getNewLabel();

        }

        public static void emitJumpChain(IRScope m, Stack<EnsureBlockInfo> ebStack)

        {

            // SSS: There are 2 ways of encoding this:

            // 1. Jump to ensure block 1, return back here, jump ensure block 2, return back here, ...

            //    Generates 3*n instrs. where n is the # of ensure blocks to execute

            // 2. Jump to ensure block 1, then to block 2, then to 3, ...

            //    Generates n+1 instrs. where n is the # of ensure blocks to execute

            // Doesn't really matter all that much since we shouldn't have deep nesting of ensure blocks often

            // but is there a reason to go with technique 1 at all??

            int n = ebStack.size();

            EnsureBlockInfo[] ebArray = ebStack.toArray(new EnsureBlockInfo[n]);

            for (int i = n-1; i >= 0; i--) {

                Label retLabel = m.getNewLabel();

                m.addInstr(new SET_RETADDR_Instr(ebArray[i].returnAddr, retLabel));

                m.addInstr(new JumpInstr(ebArray[i].start));

                m.addInstr(new LABEL_Instr(retLabel));

            }

        }

    }

    private int _lastProcessedLineNum = -1;

    private Stack<EnsureBlockInfo> _ensureBlockStack = new Stack<EnsureBlockInfo>();

    // Stack encoding nested rescue blocks -- this just tracks the start label of the blocks

    private Stack<Label> _rescueBlockLabelStack = new Stack<Label>();

    public static Node buildAST(boolean isCommandLineScript, String arg) {

        Ruby ruby = Ruby.getGlobalRuntime();

        if (isCommandLineScript) {

            // inline script

            return ruby.parse(ByteList.create(arg), "-e", null, 0, false);

        } else {

            // from file

            FileInputStream fis = null;

            try {

                File file = new File(arg);

                fis = new FileInputStream(file);

                long size = file.length();

                byte[] bytes = new byte[(int)size];

                fis.read(bytes);

                System.out.println("-- processing " + arg + " --");

                return ruby.parse(new ByteList(bytes), arg, null, 0, false);

            } catch (IOException ioe) {

                throw new RuntimeException(ioe);

            } finally {

                try { if (fis != null) fis.close(); } catch(Exception e) { }

            }

        }

    }

    public Node skipOverNewlines(IRScope s, Node n) {

        if (n.getNodeType() == NodeType.NEWLINENODE) {

            // Do not emit multiple line number instrs for the same line

            int currLineNum = n.getPosition().getStartLine();

            if (currLineNum != _lastProcessedLineNum) {

               s.addInstr(new LineNumberInstr(s, currLineNum));

               _lastProcessedLineNum = currLineNum;

            }

        }

        while (n.getNodeType() == NodeType.NEWLINENODE)

            n = ((NewlineNode)n).getNextNode();

        return n;

    }

    public Operand generateJRubyUtilityCall(IRScope m, MethAddr meth, Operand receiver, Operand[] args) {

        Variable ret = m.getNewTemporaryVariable();

        m.addInstr(new JRubyImplCallInstr(ret, meth, receiver, args));

        return ret;

    }

    public Operand build(Node node, IRScope m) {

        if (node == null) {

            return null;

        }

        if (m == null) {

            System.out.println("Got a null scope!");

            throw new NotCompilableException("Unknown node encountered in builder: " + node);

        }

        switch (node.getNodeType()) {

            case ALIASNODE: return buildAlias((AliasNode) node, m); // done -- see FIXME

            case ANDNODE: return buildAnd((AndNode) node, m); // done

            case ARGSCATNODE: return buildArgsCat((ArgsCatNode) node, m); // done

            case ARGSPUSHNODE: return buildArgsPush((ArgsPushNode) node, m); // Nothing to do for 1.8

            case ARRAYNODE: return buildArray(node, m); // done

            case ATTRASSIGNNODE: return buildAttrAssign((AttrAssignNode) node, m); // done

            case BACKREFNODE: return buildBackref((BackRefNode) node, m); // done

            case BEGINNODE: return buildBegin((BeginNode) node, m); // done

            case BIGNUMNODE: return buildBignum((BignumNode) node, m); // done

            case BLOCKNODE: return buildBlock((BlockNode) node, m); // done

            case BREAKNODE: return buildBreak((BreakNode) node, (IRExecutionScope)m); // done?

            case CALLNODE: return buildCall((CallNode) node, m); // done

            case CASENODE: return buildCase((CaseNode) node, m); // done

            case CLASSNODE: return buildClass((ClassNode) node, m); // done

            case CLASSVARNODE: return buildClassVar((ClassVarNode) node, m); // done

            case CLASSVARASGNNODE: return buildClassVarAsgn((ClassVarAsgnNode) node, m); // done

            case CLASSVARDECLNODE: return buildClassVarDecl((ClassVarDeclNode) node, m); // done

            case COLON2NODE: return buildColon2((Colon2Node) node, m); // done

            case COLON3NODE: return buildColon3((Colon3Node) node, m); // done

            case CONSTDECLNODE: return buildConstDecl((ConstDeclNode) node, m); // done

            case CONSTNODE: return searchConst(m, ((ConstNode) node).getName()); // done

            case DASGNNODE: return buildDAsgn((DAsgnNode) node, m); // done

            case DEFINEDNODE: return buildDefined(node, m); // SSS FIXME: Incomplete

            case DEFNNODE: return buildDefn((MethodDefNode) node, m); // done

            case DEFSNODE: return buildDefs((DefsNode) node, m); // done

            case DOTNODE: return buildDot((DotNode) node, m); // done

            case DREGEXPNODE: return buildDRegexp((DRegexpNode) node, m); // done

            case DSTRNODE: return buildDStr((DStrNode) node, m); // done

            case DSYMBOLNODE: return buildDSymbol(node, m); // done

            case DVARNODE: return buildDVar((DVarNode) node, m); // done

            case DXSTRNODE: return buildDXStr((DXStrNode) node, m); // done

            case ENSURENODE: return buildEnsureNode(node, m); // done

            case EVSTRNODE: return buildEvStr((EvStrNode) node, m); // done

            case FALSENODE: return buildFalse(node, m); // done

            case FCALLNODE: return buildFCall((FCallNode) node, m); // done

            case FIXNUMNODE: return buildFixnum((FixnumNode) node, m); // done

//            case FLIPNODE: return buildFlip(node, m); // SSS FIXME: What code generates this AST?

            case FLOATNODE: return buildFloat((FloatNode) node, m); // done